home *** CD-ROM | disk | FTP | other *** search
/ Chip 2005 March / CMCD0305.ISO / Software / Shareware / Programare / restuner / ResTuner_setup.exe / {app} / restuner.chm / example.txt < prev    next >
Encoding:
Text File  |  2005-01-11  |  8.2 KB  |  215 lines
  1. //-----------------------------------------------------------------------------
  2. // Resource Tuner Demo Plug-In
  3. // (c)2001 by Yuri Rai/Heaventools ltd.
  4. // http://www.heaventools.com
  5. //
  6. // Pascal (Delphi):  t12dll.dpr
  7. //-----------------------------------------------------------------------------
  8.  
  9. library t12dll;
  10.  
  11. uses
  12.  Windows,
  13.  Messages;
  14.  
  15. {$R *.RES}
  16.  
  17. const
  18.  IName = 'Resource Tuner Demo PlugIn';
  19.  
  20.  
  21. //-----------------------------------------------------------------------------
  22. // Prototype of function which allocates memory.  
  23. //
  24. // Used only to return results to Resource Tuner.
  25. // All other memory allocation should use standard library calls.
  26. //
  27. // Rather than being permanently loaded into memory, the plug-in uses this  
  28. // function at run-time, to request a buffer of the necessary size from  
  29. // ResTuner where the plug-in can store the results of an operation. The 
  30. // plug-in does not need to clear the input buffer, or de-allocate the space 
  31. // after use, as these tasks are performed by Resource Tuner.
  32. //
  33. // Input : Size - DWORD 
  34. //              - Size of requested memory
  35. // OutPut: Pointer
  36. //              - The pointer to allocated memory. In case of failure 
  37. //                when allocating memory returns nil.
  38.  type
  39.  PMemoryAllocator = ^TMemoryAllocator;
  40.  TMemoryAllocator = function (Size: DWORD): Pointer; stdcall;
  41.  
  42.  
  43. //-----------------------------------------------------------------------------
  44. // CallBack Events
  45. const
  46.  evID_PostLogInfo = 0;
  47.  
  48. // The prototype of the function, used by Plug-in to inform Resource Tuner of various 
  49. //events that have occurred at run time.
  50. //
  51. // IMPORTANT: Currently, only 'Post data to log' is supported.  
  52. //            For compatibility with future versions of Resource Tuner, use  
  53. //            ONLY PREDEFINED EVENT TYPES.
  54. //
  55. // Input : None
  56. // Output: dwPGIID   - DWORD
  57. //              - Interface ID. It is used to uniquely specify a particular event  
  58. //                issued by the plug-in if several functions are executing at 
  59. //                the same time.
  60. //
  61. //                IMPORTANT: Only the Interface ID values received from Resource Tuner 
  62. //                           should be used.              
  63. //                 
  64. //         dwEventID - DWORD
  65. //              - Identifier of the occurred event.
  66. //
  67. //         pcMessage - Pointer
  68. //              - Pointer to the data that is necessary to transmit to Resource Tuner.
  69. //
  70. type
  71.  PPGICallBack = ^TPGICallBack;
  72.  TPGICallBack = procedure (dwPGIID: DWORD; dwEventID: DWORD; pcMessage: PChar); stdcall;
  73.  
  74.  
  75. //--------------------------------------------------------------------------------------
  76. // The structure by which interaction with Resource Tuner is achieved. 
  77. // ATTENTION! Under no circumstances should you modify the values marked as 
  78. //            Read Only! Changing these values may adversely affect the operation 
  79. //            of the program.            
  80. type
  81.  PPGIParamsBlock = ^TPGIParamsBlock;
  82.  TPGIParamsBlock = record
  83.   pMemAllocator       : PMemoryAllocator; // The address of the procedure
  84.                                           // allocating memory. The procedure
  85.                                           // is required for de-allocating
  86.                                           // memory correctly after use. 
  87.   pCallBack           : Pointer;          // Pointer to CallBack function.
  88.   pInBuff             : Pointer;          // Pointer to input buffer.
  89.   pOutBuff            : Pointer;          // Pointer to output buffer.
  90.                                           // Filled by plug-in if execution of  
  91.                                           // the function was successful.             
  92.                                                    
  93.   dwInSize            : DWORD;            // Size of input buffer.
  94.   dwOutSize           : DWORD;            // Size of output buffer.
  95.                                           // Filled by plug-in if execution of  
  96.                                           // the function was successful.
  97.   dwInterface         : DWORD;            // Interface ID. Read Only!
  98.   dwIndex             : DWORD;            // Index. (For internal use by ResTuner). 
  99.                                           // Read Only!
  100.  end;
  101.  
  102.  
  103.  
  104. //-----------------------------------------------------------------------------
  105. // The function executed prior to beginning data processing by Resource Tuner.
  106. // This function provides a generic means to perform any startup processing.
  107. // In the body of this function it is possible, for example, to place the code 
  108. // to unpack any packed files, and transmit them to Resource Tuner for further
  109. // processing. 
  110. //
  111. // Input:  - the function receives PPGIParamsBlock and uses values sent to it.
  112. // Output: - returns True if execution was successful, otherwise it returns 
  113. //           False.
  114. //
  115. function PexPreloadImage(pPGIPB: PPGIParamsBlock): Boolean; stdcall;
  116. const
  117.  DemoMessage1 = 'Emulating Execution...';
  118.  DemoMessage2 = 'Allocating memory ...';
  119.  DemoMessage3 = 'Copy InBuff to OutBuff...';
  120.  DemoMessage4 = 'Runtime error: PexPreloadImage';
  121.  
  122. var MA : TMemoryAllocator;
  123.     CB : TPGICallBack;
  124. begin
  125.  // We have to return True if success and False in all 
  126.  // other cases (error occurred, haven't found data we can work with).
  127.  Result := False;
  128.  // Getting pointer to CallBack function
  129.  @CB := pPGIPB.pCallBack;
  130.  // Getting pointer to function that allocates memory
  131.  @MA := pPGIPB.pMemAllocator;
  132.  
  133.  // Emulating execution of the function
  134.  try
  135.   // Posting an event to the log.
  136.   if (@CB <> nil) then
  137.      CB(pPGIPB.dwInterface, evID_PostLogInfo, PChar(DemoMessage1));
  138.  
  139.   // Place your code here. For example, we will move input buffer to
  140.   // output buffer.
  141.   //
  142.   //***************************************************************************
  143.   // Posting an event to the log.
  144.   if (@CB <> nil) then
  145.      CB(pPGIPB.dwInterface, evID_PostLogInfo, PChar(DemoMessage2));
  146.  
  147.   // Asking Resource Tuner for allocating memory, and filling out the required 
  148.   //fields in the structure. 
  149.   pPGIPB.pOutBuff  := MA(pPGIPB.dwInSize);
  150.   pPGIPB.dwOutSize := pPGIPB.dwInSize;
  151.  
  152.   // Moving data from one buffer to another.
  153.   System.Move(pPGIPB.pInBuff^, pPGIPB.pOutBuff^, pPGIPB.dwInSize);
  154.  
  155.   // Posting an event to the log.
  156.   if (@CB <> nil) then
  157.      CB(pPGIPB.dwInterface, evID_PostLogInfo, PChar(DemoMessage3));
  158.  
  159.   // Everything is OK
  160.   Result := True;
  161.   //***************************************************************************
  162.   //
  163.  except
  164.   // An error occurred while executing. Posting an event to the log.
  165.   if (@CB <> nil) then
  166.      CB(pPGIPB.dwInterface, evID_PostLogInfo, PChar(DemoMessage4));
  167.  end;
  168. end;
  169.  
  170.  
  171. //---------------------------------------------------------------------------
  172. // Optional procedure.
  173. //
  174. // If this procedure is present, Resource Tuner adds an entry titled "Plug-ins - 
  175. // About <Name>"  to the menu.  The name is obtained by Resource Tuner when the 
  176. // plug-in is registered.  This menu options allows infomormation about the 
  177. // plug-in to be displayed to the user.
  178. //
  179. procedure PexAboutPlugIn; Export; StdCall;
  180. var S : String;
  181. begin
  182.  // Place your code that displays 'About' info here.
  183.  // We are just showing MessageBox.
  184. //***************************************************************************
  185.  S := IName + '.' + #$0D#$0A +'Version 1.0';
  186.  Windows.MessageBox(0, PChar(S), PChar('About'), MB_OK or MB_ICONINFORMATION);
  187. end;
  188.  
  189.  
  190. //---------------------------------------------------------------------------
  191. // The procedure called at Plug-in registration.
  192. //
  193. //  This should return to Resource Tuner a pointer to the line, which contains the 
  194. //  plug-in name. Resource Tuner uses this to associate the plug-in with any menu 
  195. //  items and events it provides.
  196. //
  197. //  IMPORTANT: The line should not be empty. The plug-in will not be registered 
  198. //             if an empty line is given.
  199. //
  200. procedure PexRegisterPlugIn(var N: PChar); Export; StdCall;
  201. begin
  202.  N := PChar(IName);
  203. end;
  204.  
  205.  
  206. //---------------------------------------------------------------------------
  207. exports
  208.   PexRegisterPlugIn   index 1,
  209.   PexAboutPlugIn      index 2,
  210.   PexPreloadImage     index 3;
  211. //---------------------------------------------------------------------------
  212.  
  213. begin
  214. end.
  215.